home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 24 / AACD 24.iso / AACD / Information / WebSites / Eyetech / DOWNLOAD / IOBLI016.LHA / IOBlixDevKit / AutoDocs / ioblixser.doc < prev   
Text File  |  1999-04-28  |  23KB  |  594 lines
  1.  
  2. TABLE OF CONTENTS
  3.  
  4. ioblixser.device/AbortIO
  5. ioblixser.device/BeginIO
  6. ioblixser.device/CloseDevice
  7. ioblixser.device/CMD_CLEAR
  8. ioblixser.device/CMD_FLUSH
  9. ioblixser.device/CMD_READ
  10. ioblixser.device/CMD_RESET
  11. ioblixser.device/CMD_START
  12. ioblixser.device/CMD_STOP
  13. ioblixser.device/CMD_WRITE
  14. ioblixser.device/GetChipInfo
  15. ioblixser.device/OpenDevice
  16. ioblixser.device/SDCMD_BREAK
  17. ioblixser.device/SDCMD_QUERY
  18. ioblixser.device/SDCMD_SETPARAMS
  19. ioblixser.device/SIOCMD_SETCTRLLINES
  20.  
  21.  
  22. ioblixser.device/AbortIO                               ioblixser.device/AbortIO
  23.  
  24.    NAME
  25.        AbortIO(ioRequest) -- abort an I/O request
  26.                A1
  27.  
  28.    FUNCTION
  29.       This is an exec.library call.
  30.  
  31.       This function attempts to aborts a specified read or write request.
  32.       If the request is active, it is stopped immediately. If the request is
  33.       queued, it is painlessly removed.  The request will be returned
  34.       in the same way any completed request it.
  35.  
  36.       After AbortIO(), you must generally do a WaitIO().
  37.  
  38.    INPUTS
  39.       IORequest  -- pointer to the IORequest Block that is to be aborted.
  40.  
  41.    RESULTS
  42.        io_Error -- if the Abort succeded, then io_Error will be #IOERR_ABORTED
  43.  
  44.            (-2) and the request will be flagged as aborted (bit 5 of 
  45.            io_Flags is set).  If the Abort failed, then the Error will be zero.
  46.  
  47.  
  48. ioblixser.device/BeginIO                               ioblixser.device/BeginIO
  49.  
  50.    NAME
  51.        BeginIO(ioRequest),deviceNode -- start up an I/O process
  52.                 A1        A6
  53.    FUNCTION
  54.        This is a direct function call to the device.  It is intended for
  55.        more advanced programmers.  See exec's DoIO() and SendIO() for
  56.        the normal method of calling devices.
  57.  
  58.        This function initiates a I/O request made to the serial
  59.        device. Other than read or write, the functions are performed 
  60.        synchronously, and do not depend on any interrupt handling 
  61.        logic (or it's associated discontinuities), and hence should
  62.        be performed as IO_QUICK.
  63.        With some exceptions, reads and writes are merely initiated by 
  64.        BeginIO, and thusly return to the caller as begun, not completed.
  65.        Completion is signalled via the standard ReplyMsg routine.
  66.        Multiple requests are handled via FIFO queueing.
  67.        One exception to this non-QUICK handling of reads and writes
  68.        is for READS when:
  69.          - IO_QUICK bit is set
  70.          - There are no pending read requests
  71.          - There is already enough data in the input buffer to satisfy
  72.            this I/O Request immediately.
  73.        In this case, the IO_QUICK flag is not cleared, and the request
  74.        is completed by the time it returns to the caller. There is no
  75.        ReplyMsg or signal bit activity in this case.
  76.           
  77.    INPUTS
  78.        ioRequest  -- pointer to an I/O Request Block of size 
  79.            io_ExtSerSize (see serial.i for size/definition), 
  80.            containing a valid command in io_Command to process,
  81.            as well as the command's other required parameters.
  82.        deviceNode -- pointer to the "ioblixser.device", as found in
  83.            the IO_DEVICE of the ioRequest.
  84.  
  85.    RESULTS
  86.        io_Error -- if the BeginIO succeded, then Error will be null.
  87.            If the BeginIO failed, then the Error will be non-zero.
  88.            I/O errors won't be reported until the io completes.
  89.  
  90.    SEE ALSO
  91.         devices/serial.h
  92.  
  93.  
  94. ioblixser.device/CloseDevice                       ioblixser.device/CloseDevice
  95.  
  96.    NAME
  97.        CloseDevice -- close the serial port
  98.  
  99.    SYNOPSIS
  100.        CloseDevice(deviceNode)
  101.                     A1
  102.    FUNCTION
  103.        This is an exec call that terminates communication with the
  104.        serial device.  Upon closing, the device's input buffer is freed.
  105.  
  106.        Note that all IORequests MUST be complete before closing.
  107.         If any are pending, your program must AbortIO() then WaitIO()
  108.        to complete them.
  109.  
  110.    INPUTS
  111.        deviceNode - pointer to the device node, set by Open
  112.  
  113.    SEE ALSO
  114.        ioblixser.device/OpenDevice
  115.  
  116.  
  117. ioblixser.device/CMD_CLEAR                           ioblixser.device/CMD_CLEAR
  118.  
  119.    NAME
  120.        Clear -- clear the serial port buffers
  121.  
  122.    FUNCTION
  123.        This command resets the serial port's read buffer pointers.
  124.  
  125.    IO REQUEST
  126.        io_Message      mn_ReplyPort initialized
  127.        io_Device       set by OpenDevice
  128.        io_Unit         set by OpenDevice
  129.        io_Command      CMD_CLEAR
  130.  
  131.    RESULTS
  132.        Error -- If the Clear succeded, then io_Error will be null.
  133.                 If the Clear failed, then the io_Error will be non-zero.
  134.  
  135.  
  136. ioblixser.device/CMD_FLUSH                           ioblixser.device/CMD_FLUSH
  137.  
  138.    NAME
  139.        Flush -- clear all queued I/O requests for the serial port
  140.  
  141.    FUNCTION
  142.        This command purges the read and write request queues for the
  143.        serial device. Flush will not affect active requests.
  144.  
  145.    IO REQUEST
  146.        io_Message      mn_ReplyPort initialized
  147.        io_Device       set by OpenDevice
  148.        io_Unit         set by OpenDevice
  149.        io_Command      CMD_FLUSH
  150.  
  151.    RESULTS
  152.        Error -- if the Flush succeded, then io_Error will be null.
  153.                  If the Flush failed, then the io_Error will be non-zero.
  154.  
  155.  
  156. ioblixser.device/CMD_READ                             ioblixser.device/CMD_READ
  157.  
  158.    NAME
  159.        Read -- read input from serial port
  160.  
  161.    FUNCTION
  162.         This command causes a stream of characters to be read in from
  163.         the serial port buffer.  The number of characters is specified
  164.         in io_Length.
  165.  
  166.         The Query function can be used to check how many characters
  167.         are currently waiting in the serial port buffer.  If more characters
  168.         are requested than are currently available, the ioRequest
  169.         will be queued until it can be satisfied.
  170.  
  171.  
  172.         The best way to handle reads is to first Query to get the number
  173.         of characters currently in the buffer.  Then post a read request
  174.         for that number of characters (or the maximum size of your buffer).
  175.  
  176.         If zero characters are in the buffer, post a request
  177.         for 1 character.  When at least one is ready, the device will return
  178.         it.  Now start over with another Query.
  179.  
  180.         Before the program exits, it must be sure to AbortIO() then WaitIO()
  181.         any outstanding ioRequests.
  182.  
  183.    IO REQUEST
  184.        io_Message      A mn_ReplyPort is required
  185.        io_Device       set by OpenDevice
  186.        io_Unit         set by OpenDevice
  187.        io_Command      CMD_READ
  188.        io_Flags        If the IOB_QUICK bit is set, read will try
  189.                         to complete the IO quickly
  190.        io_Length       number of characters to receive.
  191.        io_Data         pointer to buffer
  192.  
  193.    RESULTS
  194.        Error -- if the Read succeded, then io_Error will be null.
  195.            If the Read failed, then io_Error will be non-zero.
  196.              io_Error will indicate problems such as parity mismatch,
  197.              break, and buffer overrun.
  198.  
  199.    SEE ALSO
  200.         ioblixser.device/SDCMD_QUERY
  201.         ioblixser.device/SDCMD_SETPARAMS
  202.  
  203.    BUGS
  204.         Having multiple outstanding read IORequests at any one time will
  205.         probably fail.
  206.  
  207.         Old documentation mentioned a mode where io_Length was set to -1.
  208.         If you want a NULL terminated read, use the io_TermArray instead.
  209.  
  210.  
  211. ioblixser.device/CMD_RESET                           ioblixser.device/CMD_RESET
  212.  
  213.    NAME
  214.        Reset -- reinitializes the serial port
  215.  
  216.    FUNCTION
  217.        This command resets the serial port to its freshly initialized
  218.        condition. It aborts all I/O requests both queued and current,
  219.        relinquishes the current buffer, obtains a new default sized
  220.        buffer, and sets the port's flags and parameters to their 
  221.        boot-up time default values. The functions places the reset
  222.        parameter values in the ioRequest block.
  223.  
  224.    IO REQUEST
  225.        io_Message      mn_ReplyPort initialized
  226.        io_Device       set by OpenDevice
  227.        io_Unit         set by OpenDevice
  228.        io_Command      CMD_RESET
  229.  
  230.    RESULTS
  231.        Error -- if the Reset succeded, then Error will be null.
  232.            If the Reset failed, then the Error will be non-zero.
  233.  
  234.  
  235. ioblixser.device/CMD_START                           ioblixser.device/CMD_START
  236.  
  237.    NAME
  238.        Start -- restart paused I/O over the serial port
  239.  
  240.    FUNCTION
  241.        This function restarts all current I/O on the serial port by 
  242.        sending an xON to the "other side", and submitting a "logical
  243.        xON" to "our side", if/when appropriate to current activity.
  244.  
  245.    IO REQUEST
  246.        io_Message      mn_ReplyPort initialized
  247.        io_Device       set by OpenDevice
  248.        io_Unit         set by OpenDevice
  249.        io_Command      CMD_START
  250.  
  251.    RESULTS
  252.  
  253.    SEE ALSO
  254.        ioblixser.device/CMD_STOP
  255.  
  256.  
  257. ioblixser.device/CMD_STOP                             ioblixser.device/CMD_STOP
  258.  
  259.    NAME
  260.        Stop -- pause all current I/O over the serial port
  261.  
  262.    FUNCTION
  263.        This command halts all current I/O on the serial port by 
  264.        sending an xOFF to the "other side", and submitting a "logical
  265.        xOFF" to "our side", if/when appropriate to current activity.
  266.  
  267.    IO REQUEST
  268.        io_Message      mn_ReplyPort initialized
  269.        io_Device       set by OpenDevice
  270.        io_Unit         set by OpenDevice
  271.        io_Command      CMD_STOP
  272.  
  273.    RESULTS
  274.  
  275.    SEE ALSO
  276.        ioblixser.device/CMD_START
  277.  
  278.  
  279. ioblixser.device/CMD_WRITE                           ioblixser.device/CMD_WRITE
  280.  
  281.    NAME
  282.        Write -- send output to serial port
  283.  
  284.    FUNCTION
  285.        This command causes a stream of characters to be written out
  286.        the serial port. The number of characters is specified in
  287.        io_Length, unless -1 is used, in which case output is sent until
  288.        a null(0x00) is encountered. 
  289.  
  290.    IO REQUEST
  291.        io_Message      must have mn_ReplyPort initialized
  292.        io_Device       set by OpenDevice
  293.        io_Unit         set by OpenDevice
  294.        io_Command      CMD_WRITE
  295.        io_Flags        Set IOF_QUICK to try quick I/O
  296.        io_Length       number of characters to transmit, or if set
  297.                        to -1 transmit until null encountered in buffer
  298.        io_Data         pointer to block of data to transmit
  299.  
  300.    RESULTS
  301.        Error -- if the Write succeded, then io_Error will be null.
  302.            If the Write failed, then the io_Error will be non-zero.
  303.  
  304.    SEE ALSO
  305.         ioblixser.device/SDCMD_SETPARAMS
  306.  
  307.  
  308. ioblixser.device/GetChipInfo                       ioblixser.device/GetChipInfo
  309.  
  310.    NAME
  311.        GetChipInfo -- get the chip's information block
  312.  
  313.    SYNOPSIS
  314.        chipInfo = GetChipInfo(ioRequest)
  315.        D0                     A0
  316.  
  317.        struct IOBlixChipNode *GetChipInfo(struct IORequest *);
  318.  
  319.    FUNCTION
  320.        Get the chip's information block, as it is returned by
  321.        ioblix.resource/ObtainChip() and ioblix.resource/FindChip(). All fields
  322.        are considered READ-ONLY, you must not change anything.
  323.  
  324.    INPUTS
  325.        ioRequest        - pointer to a valid ioRequest after a successfull
  326.                           OpenDevice() call.
  327.  
  328.    RESULTS
  329.        chipInfo  - the chip's information block
  330.  
  331.    SEE ALSO
  332.        ioblix.resource/ObtainChip, ioblix.resource/FindChip
  333.  
  334.  
  335. ioblixser.device/OpenDevice                         ioblixser.device/OpenDevice
  336.  
  337.    NAME
  338.        OpenDevice -- Request an opening of the serial device.
  339.  
  340.    SYNOPSIS
  341.        error = OpenDevice("ioblixser.device", unit, ioRequest, flags)
  342.        D0                 A0                  D0    A1         D1
  343.  
  344.         BYTE OpenDevice(STRPTR, ULONG, struct IOExtSer *, ULONG);
  345.  
  346.    FUNCTION
  347.        This is an exec call.  Exec will search for the ioblixser.device, and
  348.        if found, will pass this call on to the device.
  349.  
  350.        Unless the shared-access bit (bit 5 of io_SerFlags) is set,
  351.        exclusive use is granted and no other access to that unit is
  352.        allowed until the owner closes it.  All the serial-specific fields
  353.        in the ioRequest are initialized to their most recent values (or
  354.        the Preferences default, for the first time open).
  355.  
  356.        If support of 7-wire handshaking (i.e. RS232-C CTS/RTS protocol)
  357.        is required, use the ioblixser.device/SDCMD_SETPARAMS command.
  358.        This feature should also be specified at inital OpenDevice() time.
  359.  
  360.    INPUTS
  361.        "ioblixser.device"  - pointer to literal string "ioblixser.device"
  362.        unit             - Must be zero, or a user setable unit number.
  363.                           (This field is used by multiple port controllers)
  364.                           Zero specifies the default serial port.
  365.        ioRequest        - pointer to an ioRequest block of size io_ExtSerSize
  366.                           to be initialized by the ioblixser.device.
  367.                           (see devices/serial.h for the definition)
  368.                           NOTE use of io_SerFlags (see FUNCTION above)
  369.                 IMPORTANT: The ioRequest block MUST be of size io_ExtSerSize,
  370.                            and zeroed (with the exeptions as noted)!
  371.        flags            - Must be zero for future compatibility
  372.  
  373.    RESULTS
  374.        D0         - same as io_Error
  375.        io_Error  - If the Open succeded, then io_Error will be null.
  376.                     If the Open failed, then io_Error will be non-zero.
  377.        io_Device - A pointer to whatever device will handle the calls
  378.                    for this unit.  This pointer may be different depending
  379.                    on what unit is requested.
  380.  
  381.    SEE ALSO
  382.         ioblixser.device/CloseDevice
  383.         ioblixser.device/SDCMD_SETPARAMS
  384.         devices/serial.h
  385.  
  386.  
  387. ioblixser.device/SDCMD_BREAK                       ioblixser.device/SDCMD_BREAK
  388.  
  389.    NAME
  390.        Break -- send a break signal over the serial line
  391.  
  392.    FUNCTION
  393.        This command sends a break signal (serial line held low for an
  394.        extended period) out the serial port.
  395.  
  396.        After a duration (user specifiable via setparams, default 250000
  397.        microseconds) the bit is reset and the signal discontinued.
  398.        If the QUEUEDBRK bit of io_SerFlags is set in the io_Request 
  399.        block, the request is placed at the back of the write-request 
  400.        queue and executed in turn. If the QUEUEDBRK bit is not set, 
  401.        the break is started immediately, control returns to the 
  402.        caller, and the timer discontinues the signal after the 
  403.        duration is completed. Be aware that calling BREAK may
  404.        affect other commands such as ABORT, FLUSH, STOP, START, etc...
  405.  
  406.    IO REQUEST
  407.        io_Message      mn_ReplyPort initialized
  408.        io_Device       set by OpenDevice
  409.        io_Unit         set by OpenDevice
  410.        io_Command      SDCMD_BREAK
  411.        io_Flags        set/reset IO_QUICK per above description
  412.  
  413.    RESULTS
  414.        Error -- if the Break succeded, then Error will be null.
  415.            If the Break failed, then the Error will be non-zero.
  416.  
  417.  
  418. ioblixser.device/SDCMD_QUERY                       ioblixser.device/SDCMD_QUERY
  419.  
  420.    NAME
  421.        Query -- query serial port/line status
  422.  
  423.    FUNCTION
  424.        This command return the status of the serial port lines and
  425.        registers. The number of unread bytes in the serial device's
  426.        read buffer is shown in io_Actual.
  427.  
  428.        The break send & received flags are cleared by a query, and
  429.        whenever a read IORequest is returned with a error
  430.        in io_Error.
  431.  
  432.    IO REQUEST
  433.        io_Message      mn_ReplyPort initialized
  434.        io_Device       preset by OpenDevice
  435.        io_Unit         preset by OpenDevice
  436.        io_Command      SDCMD_QUERY
  437.  
  438.    RESULTS
  439.        io_Status        BIT  ACTIVE  FUNCTION
  440.  
  441.               LSB       0    ---    reserved
  442.                         1    ---    reserved
  443.                         2    high   Ring Indicator
  444.                         3    low    Data Set Ready
  445.                         4    low    Clear To Send
  446.                         5    low    Carrier Detect
  447.                         6    low    Ready To Send
  448.                         7    low    Data Terminal Ready
  449.               MSB       8    high   hardware overrun
  450.                         9    high   break sent (most recent output)
  451.                        10    high   break received (as latest input)
  452.                        11    high   transmit x-OFFed       
  453.                        12    high   receive x-OFFed       
  454.                     13-15    ---    reserved
  455.  
  456.        io_Actual       set to count of unread input characters
  457.  
  458.        io_Error -- Query will always succeded.
  459.  
  460.  
  461. ioblixser.device/SDCMD_SETPARAMS               ioblixser.device/SDCMD_SETPARAMS
  462.  
  463.    NAME
  464.        SetParams -- change parameters for the serial port
  465.  
  466.    FUNCTION
  467.        This command allows the caller to change parameters for the
  468.        serial device. Except for xON-xOFF enable/disable, it will
  469.        reject a setparams call if any reads or writes are active 
  470.        or pending. 
  471.        Note specifically:
  472.  
  473.     1. Valid input for io_Baud is between 110 and 921600 baud inclusive;
  474.        asynchronous i/o above 32KB (especially on a busy system) may
  475.        be ambitious.
  476.     2. The EOFMODE and QUEUEDBRK bits of io_SerFlags can be set/reset 
  477.        in the io_Rqst block without a call to SetParams. The SHARED 
  478.        and 7WIRE bits of io_SerFlags can be used in OpenDevice calls.
  479.        ALL OTHER PARAMETERS CAN ONLY BE CHANGED BY THE SetParams 
  480.        COMMAND.
  481.     3. RBufLen must be at least 64.  The buffer may be any multiple of
  482.         64 bytes.
  483.     4. If not used, io_ExtFlags MUST be set to zero.
  484.     5. xON-xOFF is by default enabled. The XDISABLED bit is the only
  485.        parameter that can be changed via a SetParams call while the
  486.        device is active. Note that this will return the value
  487.        SerErr_DevBusy in the io_Error field.
  488.         
  489.         xON/xOFF handshaking is inappropriate for certain binary transfer
  490.         protocalls, such as Xmodem.  The binary data might contain the
  491.         xON (ASCII 17) and xOFF (ASCII 19) characters.
  492.  
  493.     6. If trying to run MIDI, you should set the RAD_BOOGIE bit of
  494.        io_SerFlags to eliminate unneeded overhead. Specifically, this skips
  495.        checks for parity, x-OFF handling, character lengths other than
  496.        8 bits, and testing for a break signal. Setting RAD_BOOGIE will
  497.        also set the XDISABLED bit.
  498.        Note that writing data (that's already in MIDI format) at MIDI rates
  499.        is easily accomplished. Using this driver alone for MIDI reads may,
  500.        however, may not be reliable, due to MIDI timestamping requirements,
  501.        and possibility of overruns in a busy multitasking and/or display
  502.        intensive environment.
  503.     7. If you select mark or space parity (see io_ExtFlags in serial.h),
  504.        this will cause the SERB_PARTY_ON bit to be set, and the setting
  505.        of SERB_PARTY_ODD to be ignored.
  506.     8. For best results, set the RAD_BOOGIE flag whenever possible.  See
  507.         #6 for details.
  508.     9. Note that at this time parity is *not* calculated for the xON-xOFF
  509.         characters.  If you have a system that is picky about the parity of
  510.         these, you must set your own xON-xOFF characters in io_CtlChar.
  511.    10. 7WIRE (CTS/RTS) handshake is bi-directional.  The external side
  512.         is expected to drop CTS several character times before the external
  513.         buffer is full.  The IOBlix-UART will drop RTS several character times
  514.         before the IOBlix-UART's buffer is full.
  515.  
  516.  
  517.    IO REQUEST
  518.        io_Message      mn_ReplyPort initialized
  519.        io_Device       preset by OpenDevice
  520.        io_Unit         preset by OpenDevice
  521.        io_Command      SDCMD_SETPARAMS (0x0B)
  522.                         NOTE that the following fields are filled in by Open 
  523.                        to reflect the serial device's current configuration.
  524.        io_CtlChar      a longword containing byte values for the
  525.                        xON,xOFF,INQ,ACK fields (respectively)
  526.                        (INQ/ACK not used at this time)
  527.        io_RBufLen      length in bytes of input buffer
  528.                         NOTE that any change in buffer size causes the
  529.                        current buffer to be deallocated and a new,
  530.                        correctly sized one to be allocated. Thusly,
  531.                        the CONTENTS OF THE OLD BUFFER ARE LOST.
  532.        io_ExtFlags     additional serial flags (bitdefs in devices/serial.h)
  533.                         mark & space parity may be specified here.
  534.        io_Baud         baud rate for reads AND writes. (See 1 above)
  535.        io_BrkTime      duration of break signal in MICROseconds
  536.        io_TermArray    ASCII descending-ordered 8-byte array of
  537.                        termination characters. If less than 8 chars
  538.                        used, fill out array w/lowest valid value.
  539.                        Terminators are checked only if EOFMODE bit of
  540.                        io_Serflags is set. (e.g. x512F040303030303 )
  541.        io_ReadLen      number of bits in read word (1-8) not including parity
  542.        io_WriteLen     number of bits in write word (1-8) "      "       "
  543.        io_StopBits     number of stop bits (0, 1 or 2)
  544.        io_SerFlags     see devices/serial.h for bit equates, NOTE that x00
  545.                        yields exclusive access, xON/OFF-enabled, no
  546.                        parity checking, 3-wire protocol and TermArray
  547.                        inactive.
  548.  
  549.    RESULTS
  550.        Error -- if the SetParams succeded, then Error will be null.
  551.            If the SetParams failed, then the Error will be non-zero.
  552.  
  553.    SEE ALSO
  554.         exec/OpenDevice
  555.  
  556.  
  557. ioblixser.device/SIOCMD_SETCTRLLINES       ioblixser.device/SIOCMD_SETCTRLLINES
  558.  
  559.    NAME
  560.        SetCTRLLines -- set state of RTS and DTR line
  561.  
  562.    FUNCTION
  563.        This command allows the caller to directly set the RTS and DTR lines to
  564.        a specific state.
  565.  
  566.    IO REQUEST
  567.        io_Message      mn_ReplyPort initialized
  568.        io_Device       preset by OpenDevice
  569.        io_Unit         preset by OpenDevice
  570.        io_Command      SIOCMD_SETCTRLLINES
  571.        io_Offset       mask which specifies the lines that are to be changed
  572.        io_Length       mask which defines the new state of affected lines
  573.  
  574.    EXAMPLE
  575.        /* drop the DTR line */
  576.        ioreq->io_Command = SIOCMD_SETCTRLLINES;
  577.        ioreq->io_Offset = SIOF_DTR; /* set new state of DTR line    */
  578.        ioreq->io_Length = 0;        /* new state is low             */
  579.        DoIO(ioreq);
  580.  
  581.        /* raise DTR again */
  582.        ioreq->io_Command = SIOCMD_SETCTRLLINES;
  583.        ioreq->io_Offset = SIOF_DTR; /* set new state of DTR line    */
  584.        ioreq->io_Length = SIOF_DTR; /* new state is high            */
  585.        DoIO(ioreq);
  586.  
  587.    RESULTS
  588.        The RTS and DTR lines will be set to the specified state.
  589.  
  590.        io_Error -- SetCTRLLines will always succeded.
  591.  
  592.  
  593.  
  594.